CM3D2 Converter.model_import

   1import os
   2import math
   3import struct
   4import time
   5import traceback
   6import bpy
   7import bpy_extras
   8import bmesh
   9import mathutils
  10from collections import Counter
  11from . import common
  12from . import compat
  13from . import cm3d2_data
  14from .translations.pgettext_functions import *
  15from .misc_OBJECT_PT_transform import CNV_OT_align_to_cm3d2_base_bone
  16
  17
  18# メインオペレーター
  19@compat.BlRegister()
  20#@bpy_extras.io_utils.orientation_helper(axis_forward='-Z', axis_up='Y')
  21class CNV_OT_import_cm3d2_model(bpy.types.Operator, bpy_extras.io_utils.ImportHelper):
  22    bl_idname = 'import_mesh.import_cm3d2_model'
  23    bl_label = "CM3D2モデル (.model)"
  24    bl_description = "カスタムメイド3D2のmodelファイルを読み込みます"
  25    bl_options = {'REGISTER'}
  26
  27    filepath = bpy.props.StringProperty(subtype='FILE_PATH')
  28    filename_ext = ".model"
  29    filter_glob = bpy.props.StringProperty(default="*.model", options={'HIDDEN'})
  30
  31    scale = bpy.props.FloatProperty(name="倍率", default=5, min=0.1, max=100, soft_min=0.1, soft_max=100, step=100, precision=1, description="インポート時のメッシュ等の拡大率です")
  32
  33    is_mesh = bpy.props.BoolProperty(name="メッシュ生成", default=True, description="ポリゴンを読み込みます、大抵の場合オンでOKです")
  34    is_remove_doubles = bpy.props.BoolProperty(name="重複頂点を結合", default=True, description="UVの切れ目でポリゴンが分かれている仕様なので、インポート時にくっつけます")
  35    is_seam = bpy.props.BoolProperty(name="シームをつける", default=True, description="UVの切れ目にシームをつけます")
  36    is_sharp = bpy.props.BoolProperty(name="Mark Sharp", default=True, description="This will mark removed doubles on your mesh as sharp (or all free edges if not removing doubles).")
  37
  38    is_convert_bone_weight_names = bpy.props.BoolProperty(name="頂点グループ名をBlender用に変換", default=False, description="全ての頂点グループ名をBlenderの左右対称編集で使えるように変換してから読み込みます")
  39    is_vertex_group_sort = bpy.props.BoolProperty(name="頂点グループを名前順ソート", default=True, description="頂点グループを名前順でソートします")
  40    is_remove_empty_vertex_group = bpy.props.BoolProperty(name="割り当てのない頂点グループを削除", default=True, description="全ての頂点に割り当てのない頂点グループを削除します")
  41
  42    reload_tex_cache = bpy.props.BoolProperty(name="テクスチャキャッシュを再構成", default=False, description="texファイルを探す際、キャッシュを再構成します")
  43    is_decorate = bpy.props.BoolProperty(name="種類に合わせてマテリアルを装飾", default=True)
  44    is_mate_data_text = bpy.props.BoolProperty(name="テキストにマテリアル情報埋め込み", default=True, description="シェーダー情報をテキストに埋め込みます")
  45
  46    is_armature = bpy.props.BoolProperty(name="アーマチュア生成", default=True, description="ウェイトを編集する時に役立つアーマチュアを読み込みます")
  47    is_armature_clean = bpy.props.BoolProperty(name="不要なボーンを削除", default=False, description="ウェイトが無いボーンを削除します")
  48    is_custom_bones = bpy.props.BoolProperty(name="Use Custom Bones", default=False, description="Use the currently selected object for custom bone shapes.")
  49    is_use_local_bones = bpy.props.BoolProperty(name="Use Local Bones", default=True, description="Use the Local Bone Data for orientation (more accurate)")
  50
  51    is_bone_data_text = bpy.props.BoolProperty(name="テキスト", default=True, description="ボーン情報をテキストとして読み込みます")
  52    is_bone_data_obj_property = bpy.props.BoolProperty(name="オブジェクトのカスタムプロパティ", default=True, description="メッシュオブジェクトのカスタムプロパティにボーン情報を埋め込みます")
  53    is_bone_data_arm_property = bpy.props.BoolProperty(name="アーマチュアのカスタムプロパティ", default=True, description="アーマチュアデータのカスタムプロパティにボーン情報を埋め込みます")
  54    texpath_dict = None
  55
  56    @classmethod
  57    def poll(cls, context):
  58        return True
  59
  60    def invoke(self, context, event):
  61        prefs = common.preferences()
  62        if prefs.model_default_path:
  63            self.filepath = common.default_cm3d2_dir(prefs.model_default_path, None, "model")
  64        else:
  65            self.filepath = common.default_cm3d2_dir(prefs.model_import_path, None, "model")
  66        self.scale = prefs.scale
  67        self.is_convert_bone_weight_names = prefs.is_convert_bone_weight_names
  68        if compat.IS_LEGACY or bpy.app.version < (2, 91):
  69            self.is_sharp = False
  70        context.window_manager.fileselect_add(self)
  71        return {'RUNNING_MODAL'}
  72
  73    def draw(self, context):
  74        prefs = common.preferences()
  75        self.layout.prop(self, 'scale')
  76
  77        box = self.layout.box()
  78        box.prop(self, 'is_mesh', icon='MESH_DATA')
  79
  80        sub_box = box.box()
  81        sub_box.enabled = self.is_mesh
  82        sub_box.label(text="メッシュ")
  83        sub_box.prop(self, 'is_remove_doubles', icon='STICKY_UVS_VERT')
  84        sub_box.prop(self, 'is_seam' , icon=compat.icon('UV_EDGESEL'))
  85        if not compat.IS_LEGACY and bpy.app.version >= (2, 91):
  86            sub_box.prop(self, 'is_sharp', icon=compat.icon('EDGESEL'))
  87
  88        sub_box = box.box()
  89        sub_box.enabled = self.is_mesh
  90        sub_box.label(text="頂点グループ")
  91        sub_box.prop(self, 'is_vertex_group_sort', icon='SORTALPHA')
  92        sub_box.prop(self, 'is_remove_empty_vertex_group', icon='DISCLOSURE_TRI_DOWN')
  93        sub_box.prop(self, 'is_convert_bone_weight_names', icon='BLENDER')
  94
  95        sub_box = box.box()
  96        sub_box.enabled = self.is_mesh
  97        sub_box.label(text="マテリアル")
  98        sub_box.prop(prefs, 'is_replace_cm3d2_tex', icon='BORDERMOVE')
  99        sub_box.prop(self, 'reload_tex_cache', icon='FILE_REFRESH')
 100        if compat.IS_LEGACY:
 101            sub_box.prop(self, 'is_decorate', icon=compat.icon('SHADING_TEXTURE'))
 102        sub_box.prop(self, 'is_mate_data_text', icon='TEXT')
 103
 104        box = self.layout.box()
 105        box.prop(self, 'is_armature', icon='ARMATURE_DATA')
 106        
 107        sub_box = box.box()
 108        sub_box.label(text="アーマチュア")
 109        sub_box.prop(self , 'is_use_local_bones'          , icon=compat.icon('GROUP_BONE'), text="Use Local Bone Data")
 110        sub_box.prop(self , 'is_armature_clean'           , icon=compat.icon('X'         ))
 111        sub_box.prop(self , 'is_convert_bone_weight_names', icon=compat.icon('BLENDER'   ), text="ボーン名をBlender用に変換")
 112        sub_box.prop(prefs, 'show_bone_in_front'          , icon=compat.icon('HIDE_OFF'  ), text="Show Bones in Front")
 113        row = sub_box.row()
 114        row.prop    (self , 'is_custom_bones'             , icon=compat.icon('BONE_DATA' ), text="Use Selected as Bone Shape"     )
 115        row.enabled = bool(context.object)
 116        
 117        box = self.layout.box()
 118        box.label(text="ボーン情報埋め込み場所")
 119        box.prop(self, 'is_bone_data_text', icon='TEXT')
 120        box.prop(self, 'is_bone_data_obj_property', icon='OBJECT_DATA')
 121        box.prop(self, 'is_bone_data_arm_property', icon='ARMATURE_DATA')
 122
 123    def execute(self, context):
 124        start_time = time.time()
 125
 126        prefs = common.preferences()
 127        prefs.model_import_path = self.filepath
 128        prefs.scale = self.scale
 129        context.window_manager.progress_begin(0, 10)
 130        context.window_manager.progress_update(0)
 131
 132        custom_bone_ob = context.active_object
 133        if not custom_bone_ob:
 134            self.is_custom_bones = False
 135
 136        #global_matrix = bpy_extras.io_utils.axis_conversion(from_forward=self.axis_forward, from_up=self.axis_up).to_4x4()
 137
 138        try:
 139            reader = open(self.filepath, 'rb')
 140        except:
 141            self.report(type={'ERROR'}, message=f_tip_("ファイルを開くのに失敗しました、アクセス不可かファイルが存在しません。file={}", self.filepath))
 142            return {'CANCELLED'}
 143
 144        self.texpath_dict = common.get_texpath_dict(reload=self.reload_tex_cache)
 145
 146        with reader:
 147            # ヘッダー
 148            ext = None
 149            try: # luvoid : utf-8 decoding could possibly throw an error here
 150                ext = common.read_str(reader)
 151            except:
 152                ext = False
 153            if ext != 'CM3D2_MESH':
 154                self.report(type={'ERROR'}, message="これはカスタムメイド3D2のモデルファイルではありません")
 155                return {'CANCELLED'}
 156            model_ver = struct.unpack('<i', reader.read(4))[0]
 157            self.report(type={'INFO'}, message=f_tip_("Model Version = {version}", version=model_ver))
 158            context.window_manager.progress_update(0.1)
 159
 160            try:
 161                # 名前群を取得
 162                model_name1 = common.read_str(reader)
 163                model_name2 = common.read_str(reader)
 164                context.window_manager.progress_update(0.2)
 165
 166                # ボーン情報読み込み
 167                bone_data = []
 168                bone_count = struct.unpack('<i', reader.read(4))[0]
 169                for i in range(bone_count):
 170                    name = common.read_str(reader)
 171                    scl = struct.unpack('<B', reader.read(1))[0]
 172                    bone_data.append({'name': name, 'scl': scl})
 173
 174                for i in range(bone_count):
 175                    parent_index = struct.unpack('<i', reader.read(4))[0]
 176                    parent_name = None
 177                    if parent_index != -1:
 178                        parent_name = bone_data[parent_index]['name']
 179                    bone_data[i]['parent_index'] = parent_index
 180                    bone_data[i]['parent_name'] = parent_name
 181
 182                for i in range(bone_count):
 183                    x, y, z = struct.unpack('<3f', reader.read(3*4))
 184                    bone_data[i]['co'] = mathutils.Vector((x, y, z))
 185
 186                    x, y, z = struct.unpack('<3f', reader.read(3*4))
 187                    w = struct.unpack('<f', reader.read(4))[0]
 188                    bone_data[i]['rot'] = mathutils.Quaternion((w, x, y, z))
 189                    if model_ver >= 2001:
 190                        use_scale = struct.unpack('<B', reader.read(1))[0]
 191                        if use_scale:
 192                            print(bone_data[i]['name'],"has scale data!")
 193                            scale_x, scale_y, scale_z = struct.unpack('<3f', reader.read(3*4))
 194                            bone_data[i]['scale'] = [scale_x, scale_y, scale_z]
 195
 196                context.window_manager.progress_update(0.3)
 197
 198                print(f_("Reading vertex, mesh, and local bone count at 0x{num:02X}", num=reader.tell()))
 199                vertex_count, mesh_count, local_bone_count = struct.unpack('<3i', reader.read(3*4))
 200
 201                # ローカルボーン情報読み込み
 202                local_bone_data = []
 203                for i in range(local_bone_count):
 204                    local_bone_data.append({'name': common.read_str(reader)})
 205
 206                for i in range(local_bone_count):
 207                    row0 = struct.unpack('<4f', reader.read(4 * 4))
 208                    row1 = struct.unpack('<4f', reader.read(4 * 4))
 209                    row2 = struct.unpack('<4f', reader.read(4 * 4))
 210                    row3 = struct.unpack('<4f', reader.read(4 * 4))
 211                    local_bone_data[i]['matrix'] = mathutils.Matrix([row0, row1, row2, row3])
 212                context.window_manager.progress_update(0.4)
 213
 214                # 頂点情報読み込み
 215                vertex_data = []
 216                print(f_("Reading vertex data at 0x{num:02X}", num=reader.tell()))
 217                extra_uv_uses = [False] * 7
 218                if model_ver >= 2102: # CR Edit Mode
 219                    extra_uv_uses = struct.unpack('<7?', reader.read(7))
 220                    print(f_("extra_uv_uses = {boollist}", boollist=extra_uv_uses))
 221                for i in range(vertex_count):
 222                    co = struct.unpack('<3f', reader.read(3 * 4))
 223                    no = struct.unpack('<3f', reader.read(3 * 4))
 224                    uv = struct.unpack('<2f', reader.read(2 * 4))
 225                    extra_uvs = [] # CR Edit
 226                    for i, used in enumerate(extra_uv_uses):
 227                        if used:
 228                            extra_uvs.append(struct.unpack('<2f', reader.read(2 * 4)))
 229                    vertex_data.append({'co': co, 'normal': no, 'uv': uv, 'extra_uvs': extra_uvs})
 230                if self.is_remove_doubles:
 231                    comparison_data = list(hash(repr(v['co']) + " " + repr(v['normal'])) for v in vertex_data)
 232                    comparison_counter = Counter(comparison_data)
 233                    comparison_data = list((comparison_counter[h] > 1) for h in comparison_data)
 234                    del comparison_counter
 235                print(f_("Reading unknown count at 0x{num:02X}", num=reader.tell()))
 236                unknown_count = struct.unpack('<i', reader.read(4))[0]
 237                for i in range(unknown_count):
 238                    struct.unpack('<4f', reader.read(4 * 4))
 239                for i in range(vertex_count):
 240                    indexes = struct.unpack('<4H', reader.read(4 * 2))
 241                    values = struct.unpack('<4f', reader.read(4 * 4))
 242                    vertex_data[i]['weights'] = list({
 243                            'index': index,
 244                            'value': value,
 245                            'name': local_bone_data[index]['name'],
 246                        } for index, value in zip(indexes, values))
 247                context.window_manager.progress_update(0.5)
 248                # 面情報読み込み
 249                face_data = []
 250                for i in range(mesh_count):
 251                    face_count = int(struct.unpack('<i', reader.read(4))[0] / 3)
 252                    datum = [tuple(reversed(struct.unpack('<3H', reader.read(3 * 2)))) for j in range(face_count)]
 253                    face_data.append(datum)
 254                context.window_manager.progress_update(0.6)
 255
 256                # マテリアル情報読み込み
 257                # TODO MaterialHandlerに変更
 258                material_data = []
 259                material_count = struct.unpack('<i', reader.read(4))[0]
 260                for i in range(material_count):
 261                    print(f_("mate count: {num} of {count} @ 0x{pos:02X}", num=i, count=material_count, pos=reader.tell()))
 262                    data = cm3d2_data.MaterialHandler.read(reader, read_header=False, version=model_ver)
 263                    data.name1 = data.name.lower()
 264                    material_data.append(data)
 265                    
 266                    # name1 = common.read_str(reader)
 267                    # name2 = common.read_str(reader)
 268                    # name3 = common.read_str(reader)
 269                    # data_list = []
 270                    # material_data.append({'name1': name1, 'name2': name2, 'name3': name3, 'data': data_list})
 271                    # while True:
 272                    #     data_type = common.read_str(reader)
 273                    #     if data_type == 'tex':
 274                    #         data_item = {'type': data_type}
 275                    #         data_list.append(data_item)
 276                    #         data_item['name'] = common.read_str(reader)
 277                    #         data_item['type2'] = common.read_str(reader)
 278                    #         if data_item['type2'] == 'tex2d':
 279                    #             data_item['name2'] = common.read_str(reader)
 280                    #             data_item['path'] = common.read_str(reader)
 281                    #             data_item['tex_map'] = struct.unpack('<4f', reader.read(4*4))
 282                    #     elif data_type == 'col':
 283                    #         name = common.read_str(reader)
 284                    #         col = struct.unpack('<4f', reader.read(4*4))
 285                    #         data_list.append({'type': data_type, 'name': name, 'color': col})
 286                    #     elif data_type == 'f':
 287                    #         name = common.read_str(reader)
 288                    #         fval = struct.unpack('<f', reader.read(4))[0]
 289                    #         data_list.append({'type': data_type, 'name': name, 'float': fval})
 290                    #     else:
 291                    #         break
 292
 293                context.window_manager.progress_update(0.8)
 294
 295                # その他情報読み込み
 296                misc_data = []
 297                while True:
 298                    #print(f_("Reading data_type at 0x{num:02X}", num=reader.tell()))
 299                    data_type = common.read_str(reader)
 300                    if data_type == 'morph':
 301                        misc_item = {'type': data_type}
 302                        misc_data.append(misc_item)
 303                        misc_item['name'] = common.read_str(reader)
 304                        misc_item['data'] = data_list = []
 305                        morph_vert_count = struct.unpack('<i', reader.read(4))[0]
 306                        morph_extra_uvs = False
 307                        if model_ver >= 2102: # CR Edit Mode
 308                            morph_extra_uvs = struct.unpack('<?', reader.read(1))[0]
 309                            misc_item['uvs'] = []
 310                            print(f_("{morph}.morph_extra_uvs @ 0x{pos:02X} = {bool}", morph=misc_item['name'], bool=morph_extra_uvs, pos=reader.tell()-1))
 311                        for i in range(morph_vert_count):
 312                            index = struct.unpack('<H', reader.read(2))[0]
 313                            co = mathutils.Vector(struct.unpack('<3f', reader.read(3 * 4)))
 314                            normal = struct.unpack('<3f', reader.read(3 * 4))
 315                            extra_uvs = () # CR Edit
 316                            if morph_extra_uvs:
 317                                extra_uvs = struct.unpack('<4f', reader.read(4 * 4))
 318                            data_list.append({'index': index, 'co': co, 'normal': normal, 'color': extra_uvs})
 319                    else:
 320                        break
 321            
 322            except UnicodeDecodeError as e:
 323                msg = [
 324                    f_tip_("Error reading file at byte 0x{num:02X}", num=reader.tell()-len(e.object)) + "\n",
 325                    str(e) + "\n",
 326                    *traceback.format_tb(e.__traceback__)
 327                ]
 328                self.report(type={'ERROR'}, message="".join(reversed(msg))[0:-1])
 329                print("".join(msg))
 330                return {'CANCELLED'}
 331            
 332            except struct.error as e:
 333                msg = [
 334                    f_tip_("Error reading file at byte 0x{num:02X}", num=reader.tell()) + "\n",
 335                    str(e) + "\n",
 336                    *traceback.format_tb(e.__traceback__)
 337                ]
 338                self.report(type={'ERROR'}, message="".join(reversed(msg))[0:-1])
 339                print("".join(msg))
 340                return {'CANCELLED'}
 341
 342            except common.CM3D2ImportException as e:
 343                msg = [
 344                    f_tip_("Error reading file at byte 0x{num:02X}", num=reader.tell()) + "\n",
 345                    str(e) + "\n",
 346                    *traceback.format_tb(e.__traceback__)
 347                ]
 348                self.report(type={'ERROR'}, message="".join(reversed(msg))[0:-1])
 349                print("".join(msg))
 350                return {'CANCELLED'}
 351
 352        context.window_manager.progress_update(1)
 353
 354        try:
 355            bpy.ops.object.mode_set(mode='OBJECT')
 356        except RuntimeError:
 357            pass
 358        bpy.ops.object.select_all(action='DESELECT')
 359
 360        # アーマチュア作成
 361        if self.is_armature:
 362            arm    = bpy.data.armatures.new(model_name1 + ".armature")
 363            arm_ob = bpy.data.objects.new  (model_name1 + ".armature", arm)
 364            compat.link(bpy.context.scene, arm_ob)
 365            compat.set_select(arm_ob, True)
 366            compat.set_active(context, arm_ob)
 367
 368            arm.show_names              = prefs.show_bone_names        
 369            arm.show_axes               = prefs.show_bone_axes         
 370            arm.show_bone_custom_shapes = prefs.show_bone_custom_shapes
 371            arm.show_group_colors       = prefs.show_bone_group_colors
 372            if compat.IS_LEGACY:
 373                arm_ob.show_x_ray = prefs.show_bone_in_front
 374            else:
 375                arm_ob.show_in_front = prefs.show_bone_in_front     
 376
 377            bpy.ops.object.mode_set(mode='EDIT')
 378
 379            is_odd_scale_bone = False
 380
 381            # 基幹ボーンのみ作成
 382            child_data = []
 383            for data in bone_data:
 384                if not data['parent_name']:
 385                    bone = arm.edit_bones.new(common.decode_bone_name(data['name'], self.is_convert_bone_weight_names))
 386                    bone.head, bone.tail = (0, 0, 0), (0, 1, 0)
 387                    bone.use_deform = False
 388
 389                    #co.x, co.y, co.z = -co.x, co.z, -co.y
 390                    #rot = compat.mul(rot, mathutils.Quaternion((0, 0, 1), math.radians(90)))
 391                    #rot.w, rot.x, rot.y, rot.z = -rot.w, -rot.x, rot.z, -rot.y
 392                    
 393                    #co  = data['co' ].copy()
 394                    #rot = data['rot'].copy()
 395                    #co.x, co.y, co.z = -co.x, -co.z, co.y
 396                    #rot.w, rot.x, rot.y, rot.z = -rot.w, -rot.x, -rot.z, rot.y
 397                    ##rot = compat.mul(rot, mathutils.Quaternion((0, 0, 1), math.radians(-90)))
 398                    #rot = compat.convert_cm_to_bl_bone_rotation(rot)
 399                    #mat = compat.mul(mathutils.Matrix.Translation(co), rot.to_matrix().to_4x4())
 400                    
 401                    co_mat  = mathutils.Matrix.Translation(data['co'].copy() * self.scale)
 402                    rot     = mathutils.Quaternion(data['rot'].copy())
 403                    #rot     = compat.convert_cm_to_bl_bone_rotation(rot)
 404                    rot_mat = rot.to_matrix().to_4x4()
 405                    #rot_mat = compat.convert_cm_to_bl_bone_rotation(rot_mat)
 406                    mat = compat.mul(co_mat, rot_mat)
 407                    mat = compat.convert_cm_to_bl_bone_rotation(mat)
 408                    mat = compat.convert_cm_to_bl_space(mat)
 409                    #mat = compat.mul(mat, compat.CM_TO_BL_LOCAL_BONE_MAT4)
 410                    
 411                    
 412                    #fix_mat_scale = mathutils.Matrix.Scale(-1, 4, (1, 0, 0))
 413                    #fix_mat_before = mathutils.Euler((math.radians(90), 0, 0), 'XYZ').to_matrix().to_4x4()
 414                    #fix_mat_after = mathutils.Euler((0, 0, math.radians(90)), 'XYZ').to_matrix().to_4x4()
 415
 416                    #compat.set_bone_matrix(bone, compat.mul4(fix_mat_scale, fix_mat_before, mat, fix_mat_after))
 417                    compat.set_bone_matrix(bone, mat)
 418
 419
 420                    bone["cm3d2_scl_bone"] = 1 if data['scl'] else 0
 421                    if 'scale' in data:
 422                        bone['cm3d2_bone_scale'] = data['scale']
 423                        scale = mathutils.Vector(data['scale'])
 424                        if ( scale - mathutils.Vector((1,1,1)) ).length > 1e-5:
 425                            is_odd_scale_bone = True
 426                            self.report(type={'WARNING'}, message=f_tip_("Bone '{bone_name}' has odd scale '{bone_scale}' (odd by {bone_diff})", bone_name=bone.name, bone_scale=scale, bone_diff=( scale - mathutils.Vector((1,1,1)) ).length))
 427                        scale *= self.scale * 0.01
 428                        scale = compat.convert_cm_to_bl_bone_rotation(scale)
 429                        bone.bbone_x = scale.x
 430                        bone.bbone_z = scale.z
 431                        #look = bone.tail - bone.head
 432                        #look *= scale.y
 433                        #bone.tail = look + bone.head
 434                else:
 435                    child_data.append(data)
 436            context.window_manager.progress_update(1.333)
 437
 438            # 子ボーンを追加していく
 439            while len(child_data):
 440                data = child_data.pop(0)
 441                parent = arm.edit_bones.get(common.decode_bone_name(data['parent_name'], self.is_convert_bone_weight_names))
 442                if parent:
 443                    bone = arm.edit_bones.new(common.decode_bone_name(data['name'], self.is_convert_bone_weight_names))
 444                    bone.parent = parent
 445                    bone.head, bone.tail = (0, 0, 0), (0, 1, 0)
 446                    bone.use_deform = False
 447
 448                    #parent_mats = []
 449                    #current_bone = bone
 450                    #while current_bone:
 451                    #    for b in bone_data:
 452                    #        if common.decode_bone_name(b['name'], self.is_convert_bone_weight_names) == current_bone.name:
 453                    #            local_co  = b['co' ].copy()
 454                    #            local_rot = b['rot'].copy()
 455                    #            break
 456                    #
 457                    #    local_co_mat  = mathutils.Matrix.Translation(local_co)
 458                    #    local_rot_mat = local_rot.to_matrix().to_4x4()        
 459                    #    parent_mats.append(compat.mul(local_co_mat, local_rot_mat))
 460                    #
 461                    #    current_bone = current_bone.parent
 462                    #parent_mats.reverse()
 463                    #
 464                    #mat = mathutils.Matrix()
 465                    #for local_mat in parent_mats:
 466                    #    mat = compat.mul(mat, local_mat)
 467                    #mat *= self.scale
 468                    #mat = compat.convert_cm_to_bl_space(mat)
 469                    #mat = compat.convert_cm_to_bl_bone_rotation(mat)
 470                     
 471                    #parent_mat    = compat.mul(
 472                    #    mathutils.Matrix.Translation(parent.matrix.to_translation()),
 473                    #    parent.matrix.to_quaternion().to_matrix().to_4x4()
 474                    #)
 475
 476                    parent_mat = parent.matrix
 477                    
 478                    local_co      = data['co' ].copy() * self.scale
 479                    local_rot     = data['rot'].copy()
 480                    #local_rot     = compat.convert_cm_to_bl_bone_rotation(rot)
 481                    local_co_mat  = mathutils.Matrix.Translation(local_co)
 482                    local_rot_mat = local_rot.to_matrix().to_4x4()
 483                    local_mat     = compat.mul(local_co_mat, local_rot_mat)
 484                    local_mat     = compat.convert_cm_to_bl_bone_space(local_mat)
 485                    #local_mat     = compat.mul(local_mat, mathutils.Matrix.Diagonal((1,1,1)).to_4x4())
 486                    mat = compat.mul(parent_mat, local_mat)
 487                    mat = compat.convert_cm_to_bl_bone_rotation(mat)
 488
 489                    
 490                    #co_mat        = compat.mul( parent.matrix.inverted(), compat.convert_cm_to_bl_local_bone_mat4(local_co_mat) )
 491                    #rot_mat       = compat.mul( local_rot_mat, compat.CM_TO_BL_LOCAL_BONE_MAT4 )
 492                    #mat           = compat.ul(co_mat, rot_mat)
 493                    #local_mat = compat.mul(local_co_mat, local_rot_mat)
 494                    #local_mat *= self.scale
 495                    #mat = compat.mul( parent.matrix, compat.convert_cm_to_bl_local_bone(local_mat) )
 496                    #mat *= self.scale
 497
 498                    #mat *= self.scale
 499
 500                    #co.x, co.y, co.z = -co.y, co.z, co.x
 501                    #rot.w, rot.x, rot.y, rot.z = rot.w, rot.y, -rot.z, -rot.x
 502
 503                    #co  = data['co' ].copy() * self.scale
 504                    #rot = data['rot'].copy()
 505                    #co.x, co.y, co.z = co.z, -co.x, co.y
 506                    ##co = compat.convert_cm_to_bl_local_bone(co)
 507                    ##rot.w, rot.x, rot.y, rot.z = rot.w, -rot.z, rot.x, -rot.y 
 508                    ##rot.w, rot.x, rot.y, rot.z = rot.w, -rot.z, rot.x, -rot.y
 509                    #local_mat = compat.mul(mathutils.Matrix.Translation(co), rot.to_matrix().to_4x4())
 510                    #mat = compat.mul( parent.matrix, local_mat )
 511                    ##mat *= self.scale
 512
 513                    #fix_mat_scale = mathutils.Matrix.Scale(-1, 4, (1, 0, 0))
 514                    #fix_mat_before = mathutils.Euler((math.radians(90), 0, 0), 'XYZ').to_matrix().to_4x4()
 515                    #fix_mat_after = mathutils.Euler((0, 0, math.radians(90)), 'XYZ').to_matrix().to_4x4()
 516
 517                    #compat.set_bone_matrix(bone, compat.mul4(fix_mat_scale, fix_mat_before, mat, fix_mat_after))
 518                    compat.set_bone_matrix(bone, mat)
 519                    
 520                    bone['cm3d2_scl_bone'] = 1 if data['scl'] else 0
 521                    if 'scale' in data:
 522                        bone['cm3d2_bone_scale'] = data['scale']
 523                        scale = mathutils.Vector(data['scale'])
 524                        if ( scale - mathutils.Vector((1,1,1)) ).length > 1e-5:
 525                            is_odd_scale_bone = True
 526                            self.report(type={'WARNING'}, message=f_tip_("Bone '{bone_name}' has odd scale '{bone_scale}' (odd by {bone_diff})", bone_name=bone.name, bone_scale=scale, bone_diff=( scale - mathutils.Vector((1,1,1)) ).length))
 527                        scale *= self.scale * 0.01
 528                        bone.bbone_x = scale.x
 529                        bone.bbone_z = scale.z
 530                        #bone.bbone_segments = scale.y
 531                        #look = bone.tail - bone.head
 532                        #look *= scale.y
 533                        #bone.tail = look + bone.head
 534                else:
 535                    child_data.append(data)
 536            context.window_manager.progress_update(1.666)
 537            
 538            # Configure bones in local bone data
 539            is_local_bones_corrupt = False
 540            base_bone = arm.edit_bones.get(common.decode_bone_name(model_name2, self.is_convert_bone_weight_names))
 541            base_bone_offset = base_bone.matrix.copy()
 542            base_bone_offset = compat.mul(mathutils.Matrix.Scale(-1, 4, (1, 0, 0)), base_bone_offset)
 543            base_bone_offset = compat.convert_bl_to_cm_bone_rotation(base_bone_offset)
 544            print(base_bone_offset)
 545            print(f"base_bone_offset @ I =\n{base_bone_offset @ mathutils.Matrix.Identity(4)}")
 546            #base_bone_offset = mathutils.Matrix.Identity(4) # compat.mul(base_bone_mat.inverted(), base_bone_mat)
 547
 548            def setup_local_bone(bone, mat, isRoot=False):
 549                pos = compat.transform_inverse(mat.transposed()).translation
 550                mat.row[3] = (0.0, 0.0, 0.0, 1.0)
 551                mat.translation = pos
 552                mat.translation *= self.scale
 553                offset_mat = mat.copy()
 554                if not common.is_descendant_of(bone, base_bone):
 555                    mat = compat.mul(base_bone_offset, mat)
 556                    #mat.translation = mat.translation + base_bone_offset.translation
 557                mat = compat.convert_cm_to_bl_bone_rotation(mat)
 558                mat = compat.mul(mathutils.Matrix.Scale(-1, 4, (1, 0, 0)), mat)
 559                
 560            
 561                # The matrices from the local bone data are more precise rotations, but make sure they aren't corrupted
 562                old_pos, old_rot, old_scale = bone.matrix.decompose()
 563                compat.set_bone_matrix(bone, mat)
 564                new_pos, new_rot, new_scale = bone.matrix.decompose()
 565                dif_pos = (new_pos-old_pos).length/self.scale
 566                dif_rot = old_rot.rotation_difference(new_rot)
 567                if dif_pos > 0.1 or dif_rot.w < .9:
 568                    print(dif_pos,  dif_rot)
 569                    is_local_bones_corrupt = True
 570                    #self.report(type={'WARNING'}, message="Found potentially corrupt local bone data, please re-import with \"Use Local Bone Data\" disabled.")
 571                return mat
 572
 573            for data in local_bone_data:
 574                if self.is_use_local_bones and data['name'] == model_name2:
 575                    bone = arm.edit_bones.get(common.decode_bone_name(data['name'], self.is_convert_bone_weight_names))
 576                    mat = mathutils.Matrix(data['matrix'])
 577                    print("Found base bone in local bone data!")
 578                    #base_bone_offset = compat.mul(compat.transform_inverse(base_bone_offset), setup_local_bone(bone, mat, isRoot=True))
 579
 580
 581            for data in local_bone_data:
 582                bone = arm.edit_bones.get(common.decode_bone_name(data['name'], self.is_convert_bone_weight_names))
 583                bone.use_deform = True
 584                if self.is_use_local_bones and not data['name'] == model_name2:
 585                    mat = mathutils.Matrix(data['matrix'])
 586                    setup_local_bone(bone, mat)
 587            
 588            
 589            def distOnRay(pos0, pos1, point):
 590                w = point - pos0
 591                d = (pos1 - pos0).normalized()
 592                return w.dot(d) / d.dot(d)
 593            
 594            # ボーン整頓
 595            for bone in arm.edit_bones:
 596                if len(bone.children) == 0:
 597                    if bone.parent:
 598                        bone.length = bone.parent.length * 0.5
 599                    else:
 600                        bone.length = 0.2 * self.scale
 601                elif len(bone.children) == 1:
 602                    co = bone.children[0].head - bone.head
 603                    bone.length = co.length
 604                elif len(bone.children) >= 2:
 605                    if bone.parent:
 606                        max_len = 0.0
 607                        for child_bone in bone.children:
 608                            if "Pelvis" in bone.name:
 609                                dist = (child_bone.head - bone.head).length
 610                            else:
 611                                dist = distOnRay(bone.head, bone.tail, child_bone.head)
 612                            if dist > max_len:
 613                                max_len = dist
 614                        bone.length = max_len
 615                    else:
 616                        bone.length = 0.2 * self.scale
 617            for bone in arm.edit_bones:
 618                if len(bone.children) == 0:
 619                    if bone.parent:
 620                        bone.length = bone.parent.length * 0.5
 621            
 622            # Make sure no bones are length 0, otherwise blender deletes them
 623            for bone in arm.edit_bones:
 624                min_length = 0.0001
 625                if bone.length < min_length:
 626                    bone.length = min_length
 627            
 628            # 一部ボーン削除
 629            if self.is_armature_clean:
 630                for bone in arm.edit_bones:
 631                    for b in local_bone_data:
 632                        name = common.decode_bone_name(b['name'], self.is_convert_bone_weight_names)
 633                        if bone.name == name:
 634                            break
 635                    else:
 636                        arm.edit_bones.remove(bone)
 637
 638            arm.layers[16] = True
 639            compat.set_display_type(arm, prefs.bone_display_type)
 640            bpy.ops.armature.select_all(action='DESELECT')
 641            bpy.ops.object.mode_set(mode='OBJECT')
 642            if self.is_custom_bones:
 643                print("Set custom bones")
 644                for pose_bone in arm_ob.pose.bones:
 645                    pose_bone.custom_shape = custom_bone_ob
 646        context.window_manager.progress_update(2)
 647
 648        if self.is_mesh:
 649            ob, me = self.create_mesh(context, model_name1, vertex_data, face_data)
 650            # オブジェクト変形
 651            CNV_OT_align_to_cm3d2_base_bone.from_bone_data(ob, bone_data, local_bone_data, base_bone_name=model_name2, scale=self.scale)
 652            context.window_manager.progress_update(3)
 653            
 654            self.create_uvs(context, me, vertex_data, extra_uv_uses)
 655            context.window_manager.progress_update(4)
 656
 657            self.create_vertex_groups(context, ob, vertex_data, local_bone_data)
 658            context.window_manager.progress_update(5)
 659
 660            self.create_shapekeys(context, ob, misc_data)
 661            context.window_manager.progress_update(6)
 662
 663            # マテリアル追加
 664            progress_count_total = 0.0
 665            for data in material_data:
 666                progress_count_total += 1 #len(data['data'])
 667            self.progress_plus_value = 1.0 / (progress_count_total if progress_count_total > 0.0 else 1.0)
 668            self.progress_count = 6.0
 669
 670            face_seek = 0
 671            mates_set = set()
 672            override = context.copy()
 673            override['object'] = ob
 674            prefs = common.preferences()
 675            for index, data in enumerate(material_data):
 676                print(f_("material count: {num} of {count}", num=index, count=material_count))
 677                if prefs.mate_unread_same_value and data.name in mates_set:
 678                    continue
 679                mates_set.add(data.name)
 680                #common.preferences().mate_unread_same_value
 681                bpy.ops.object.material_slot_add(override)
 682                mate = context.blend_data.materials.new(data.name)#['name1'])
 683                #mate['shader1'] = data['name2']
 684                #mate['shader2'] = data['name3']
 685
 686                ob.material_slots[-1].material = mate
 687                # 面にマテリアル割り当て
 688                for i in range(face_seek, face_seek + len(face_data[index])):
 689                    me.polygons[i].material_index = index
 690                face_seek += len(face_data[index])
 691
 692                # テクスチャ追加
 693                if compat.IS_LEGACY:
 694                    #self.create_mateprop_old(context, me, texes_set, mate, index, data)
 695                    cm3d2_data.MaterialHandler.apply_to_old(override, mate, data)
 696                    common.decorate_material(mate, self.is_decorate, me, index)
 697                else:
 698                    #self.create_mateprop(context, me, texes_set, mate, index, data)
 699                    cm3d2_data.MaterialHandler.apply_to(override, mate, data)
 700                    common.decorate_material(mate, self.is_decorate, me, index)
 701                common.setup_material(mate)
 702
 703            ob.active_material_index = 0
 704            context.window_manager.progress_update(7)
 705
 706            # メッシュ整頓
 707            pre_mesh_select_mode = context.tool_settings.mesh_select_mode[:]
 708            
 709            # Too buggy on versions before 2.91 so just disable it outright
 710            #if self.is_sharp and (compat.IS_LEGACY or bpy.app.version < (2, 91)):
 711            #    context.tool_settings.mesh_select_mode = (False, True, False)
 712            #    bpy.ops.object.mode_set(mode='EDIT')
 713            #    
 714            #    bpy.ops.mesh.select_non_manifold(extend=False, use_wire=True, use_boundary=True, use_multi_face=False, use_non_contiguous=False, use_verts=False)
 715            #    for is_comparison, vert in zip(comparison_data, me.vertices):
 716            #        if is_comparison:
 717            #            vert.select = False
 718            #    bpy.ops.mesh.mark_sharp(use_verts=False)
 719            #
 720            #    bpy.ops.object.mode_set(mode='OBJECT')
 721
 722            can_mark_sharp = not compat.IS_LEGACY and bpy.app.version >= (2, 91)
 723
 724            if self.is_remove_doubles:
 725                context.tool_settings.mesh_select_mode = (True, False, False)
 726                bpy.ops.object.mode_set(mode='EDIT')
 727                if not self.is_sharp or not can_mark_sharp:
 728                    bpy.ops.mesh.select_all(action='DESELECT')
 729                    bpy.ops.object.mode_set(mode='OBJECT')
 730                    for is_comparison, vert in zip(comparison_data, me.vertices):
 731                        if is_comparison:
 732                            vert.select = True
 733                    bpy.ops.object.mode_set(mode='EDIT')
 734                else:
 735                    bpy.ops.mesh.select_all(action='SELECT')
 736                
 737                if not can_mark_sharp:
 738                    bpy.ops.mesh.remove_doubles(threshold=0.000001/5 * self.scale)
 739                else:
 740                    bpy.ops.mesh.remove_doubles(threshold=0.000001/5 * self.scale, use_sharp_edge_from_normals=self.is_sharp)
 741                bpy.ops.object.mode_set(mode='OBJECT')
 742            
 743            context.tool_settings.mesh_select_mode = pre_mesh_select_mode
 744
 745            if self.is_seam:
 746                bpy.ops.object.mode_set(mode='EDIT')
 747                bpy.ops.mesh.select_all(action='SELECT')
 748                bpy.ops.uv.select_all(action='SELECT')
 749                bpy.ops.uv.seams_from_islands()
 750                bpy.ops.object.mode_set(mode='OBJECT')
 751            bpy.ops.object.mode_set(mode='EDIT')
 752            bpy.ops.mesh.select_all(action='DESELECT')
 753            bpy.ops.object.mode_set(mode='OBJECT')
 754
 755            if self.is_armature:
 756                mod = ob.modifiers.new("Armature", 'ARMATURE')
 757                mod.object = arm_ob
 758                compat.set_active(context, arm_ob)
 759                bpy.ops.object.parent_set(type='OBJECT', keep_transform=True)
 760                compat.set_active(context, ob)
 761        context.window_manager.progress_update(8)
 762
 763        # マテリアル情報のテキスト埋め込み
 764        if self.is_mate_data_text:
 765            for index, data in enumerate(material_data):
 766                txt_name = "Material:" + str(index)
 767                if txt_name in context.blend_data.texts:
 768                    txt = context.blend_data.texts[txt_name]
 769                    txt.clear()
 770                else:
 771                    txt = context.blend_data.texts.new(txt_name)
 772                txt.write(data.to_text())
 773                
 774                # txt.write("1000" + "\n")
 775                # txt.write(data['name1'].lower() + "\n")
 776                # txt.write(data['name1'] + "\n")
 777                # txt.write(data['name2'] + "\n")
 778                # txt.write(data['name3'] + "\n")
 779                # txt.write("\n")
 780                # for tex_data in data['data']:
 781                #     txt.write(tex_data['type'] + "\n")
 782                #     if tex_data['type'] == 'tex':
 783                #         txt.write("\t" + tex_data['name'] + "\n")
 784                #         txt.write("\t" + tex_data['type2'] + "\n")
 785                #         if tex_data['type2'] == 'tex2d':
 786                #             txt.write("\t" + tex_data['name2'] + "\n")
 787                #             txt.write("\t" + tex_data['path'] + "\n")
 788                #             map_list = tex_data['tex_map']
 789                #             tex_map = " ".join([str(map_list[0]), str(map_list[1]), str(map_list[2]), str(map_list[3])])
 790                #             txt.write("\t" + tex_map + "\n")
 791                #     elif tex_data['type'] == 'col':
 792                #         txt.write("\t" + tex_data['name'] + "\n")
 793                #         col = " ".join([str(tex_data['color'][0]), str(tex_data['color'][1]), str(tex_data['color'][2]), str(tex_data['color'][3])])
 794                #         txt.write("\t" + col + "\n")
 795                #     elif tex_data['type'] == 'f':
 796                #         txt.write("\t" + tex_data['name'] + "\n")
 797                #         txt.write("\t" + str(tex_data['float']) + "\n")
 798                # txt.current_line_index = 0
 799        context.window_manager.progress_update(9)
 800
 801        # ボーン情報のテキスト埋め込み
 802        if self.is_bone_data_text:
 803            if "BoneData" in context.blend_data.texts:
 804                txt = context.blend_data.texts["BoneData"]
 805                txt.clear()
 806            else:
 807                txt = context.blend_data.texts.new("BoneData")
 808        for i, data in enumerate(bone_data):
 809            s = ",".join([data['name'], str(data['scl']), ""])
 810            parent_index = data['parent_index']
 811            if -1 < parent_index:
 812                s += bone_data[parent_index]['name'] + ","
 813            else:
 814                s += "None" + ","
 815            s += " ".join([str(data['co'][0]), str(data['co'][1]), str(data['co'][2])]) + ","
 816            s += " ".join([str(data['rot'][0]), str(data['rot'][1]), str(data['rot'][2]), str(data['rot'][3])])
 817            if model_ver >= 2001:
 818                if 'scale' in data:
 819                    s += ",1," + " ".join(map(str, data['scale']))
 820                else:
 821                    s += ",0"
 822
 823            if self.is_bone_data_text:
 824                txt.write(s + "\n")
 825            if self.is_mesh and self.is_bone_data_obj_property:
 826                ob["BoneData:" + str(i)] = s
 827            if self.is_armature and self.is_bone_data_arm_property:
 828                arm["BoneData:" + str(i)] = s
 829        if self.is_bone_data_text:
 830            txt['BaseBone'] = model_name2
 831            txt.current_line_index = 0
 832        context.window_manager.progress_update(10)
 833
 834        # ローカルボーン情報のテキスト埋め込み
 835        if self.is_bone_data_text:
 836            if "LocalBoneData" in context.blend_data.texts:
 837                txt = context.blend_data.texts["LocalBoneData"]
 838                txt.clear()
 839            else:
 840                txt = context.blend_data.texts.new("LocalBoneData")
 841        for i, data in enumerate(local_bone_data):
 842            s = data['name'] + ","
 843
 844            mat_list = list(data['matrix'][0])
 845            mat_list.extend(list(data['matrix'][1]))
 846            mat_list.extend(list(data['matrix'][2]))
 847            mat_list.extend(list(data['matrix'][3]))
 848            for j, f in enumerate(mat_list):
 849                mat_list[j] = str(f)
 850            s += " ".join(mat_list)
 851
 852            if self.is_bone_data_text:
 853                txt.write(s + "\n")
 854            if self.is_mesh and self.is_bone_data_obj_property:
 855                ob["LocalBoneData:" + str(i)] = s
 856            if self.is_armature and self.is_bone_data_arm_property:
 857                arm["LocalBoneData:" + str(i)] = s
 858        if self.is_bone_data_text:
 859            txt['BaseBone'] = model_name2
 860            txt.current_line_index = 0
 861
 862        if self.is_mesh and self.is_bone_data_obj_property:
 863            ob['BaseBone'] = model_name2
 864            if model_ver >= 1000:
 865                ob['ModelVersion'] = model_ver
 866        if self.is_armature and self.is_bone_data_arm_property:
 867            arm['BaseBone'] = model_name2
 868            if model_ver >= 1000:
 869                arm['ModelVersion'] = model_ver
 870        context.window_manager.progress_end()
 871
 872        require_time = time.time() - start_time
 873        filesize = os.path.getsize(self.filepath)
 874        filesize_str = "バイト"
 875        if 1024 * 1024 < filesize:
 876            filesize = filesize / (1024 * 1024.0)
 877            filesize_str = "MB"
 878        elif 1024 < filesize:
 879            filesize = filesize / 1024.0
 880            filesize_str = "KB"
 881        self.report(type={'INFO'}, message=f_tip_("modelのインポートが完了しました ({} {}/ {:.2f} 秒)", filesize, filesize_str, require_time))
 882        
 883        if is_odd_scale_bone:
 884            self.report(type={'WARNING'}, message="Found bone with a scale not equal to 1.")
 885        if is_local_bones_corrupt:
 886            self.report(type={'ERROR'}, message="Found potentially corrupt local bone data, please re-import with \"Use Local Bone Data\" disabled.")
 887        return {'FINISHED'}
 888
 889    def create_mesh(self, context, model_name1, vertex_data, face_data) -> (bpy.types.Object, bpy.types.Mesh):
 890        # メッシュ作成
 891        me = context.blend_data.meshes.new(model_name1)
 892        verts, faces = [], []
 893        for data in vertex_data:
 894            #co = list(data['co'][:])
 895            #co[0] = -co[0]
 896            #co[0] *= self.scale
 897            #co[1] *= self.scale
 898            #co[2] *= self.scale
 899            co = compat.convert_cm_to_bl_space( mathutils.Vector(data['co']) * self.scale )
 900            #co = mathutils.Vector(data['co']) * self.scale
 901            verts.append(co)
 902        context.window_manager.progress_update(2.25)
 903        for data in face_data:
 904            faces.extend(data)
 905        context.window_manager.progress_update(2.5)
 906        me.from_pydata(verts, [], faces)
 907
 908        # オブジェクト化
 909        ob = context.blend_data.objects.new(model_name1, me)
 910        ob.rotation_mode = 'QUATERNION'
 911        compat.link(context.scene, ob)
 912        compat.set_select(ob, True)
 913        compat.set_active(context, ob)
 914        bpy.ops.object.shade_smooth()
 915        context.window_manager.progress_update(2.75)
 916
 917        # Custom Split Normals
 918        #normals_color = me.vertex_colors.new(name=f"Basis_normals", do_init=False) or me.vertex_colors[-1]
 919        #for vert_index, vert in enumerate(vertex_data):
 920        #    no = compat.convert_cm_to_bl_space( mathutils.Vector(vert['normal']) ) #mathutils.Vector(vert['normal']) * mathutils.Vector((-1,1,1)) #
 921        #    no.normalize()
 922        #    print(no)
 923        #    for loop_index in vert_loops[vert_index]:
 924        #        #normals[loop_index] = no
 925        #        normals_color.data[loop_index].color = ( # convert from range(-1, 1) to range(0, 1)
 926        #            *no, #*(no * 0.5 + mathutils.Vector([0.5]*3)),
 927        #            1,
 928        #        )
 929        #me.normals_split_custom_set(normals)
 930        me.normals_split_custom_set_from_vertices(
 931            tuple(
 932                compat.convert_cm_to_bl_space( mathutils.Vector(vert['normal']) )
 933                for vert in vertex_data
 934            )
 935        )
 936        me.use_auto_smooth = True
 937
 938        return ob, me
 939
 940    def create_vertex_groups(self, context, ob, vertex_data, local_bone_data):
 941        # 頂点グループ作成
 942        for data in local_bone_data:
 943            ob.vertex_groups.new(name=common.decode_bone_name(data['name'], self.is_convert_bone_weight_names))
 944        context.window_manager.progress_update(4.333)
 945
 946        for vert_index, data in enumerate(vertex_data):
 947            for weight in data['weights']:
 948                if 0.0 < weight['value']:
 949                    vertex_group = ob.vertex_groups[common.decode_bone_name(weight['name'], self.is_convert_bone_weight_names)]
 950                    vertex_group.add([vert_index], weight['value'], 'REPLACE')
 951        context.window_manager.progress_update(4.666)
 952
 953        if self.is_vertex_group_sort:
 954            bpy.ops.object.vertex_group_sort(sort_type='NAME')
 955
 956        if self.is_remove_empty_vertex_group:
 957            for vg in ob.vertex_groups[:]:
 958                for vert in ob.data.vertices:
 959                    for group in vert.groups:
 960                        if group.group == vg.index:
 961                            if 0.0 < group.weight:
 962                                break
 963                    else: # if for-loop didn't break
 964                        continue
 965                    break
 966                else: # if for-loop didn't break
 967                    ob.vertex_groups.remove(vg)
 968        
 969        ob.vertex_groups.active_index = 0
 970    
 971    def create_uvs(self, context, me, vertex_data, extra_uv_uses):
 972        # UV作成
 973        bm = bmesh.new()
 974        bm.from_mesh(me)
 975        bm.loops.layers.uv.new(f_data_("MainUV"))
 976        for i, used in enumerate(extra_uv_uses):    
 977            if used:
 978                bm.loops.layers.uv.new(f_data_("ExtraUV{num}", num=i))
 979        for face in bm.faces:
 980            for loop in face.loops:
 981                loop[bm.loops.layers.uv[0]].uv = vertex_data[loop.vert.index]['uv']
 982                for extra_uv_index, extra_uv in enumerate(vertex_data[loop.vert.index]['extra_uvs']):
 983                    loop[bm.loops.layers.uv[extra_uv_index+1]].uv = extra_uv
 984        bm.to_mesh(me)
 985        bm.free()
 986
 987    def create_shapekeys(self, context, ob, misc_data):
 988        # モーフ追加
 989        me = ob.data
 990
 991        is_use_attributes = (not compat.IS_LEGACY and bpy.app.version >= (2,92))
 992        is_fast_create = (not compat.IS_LEGACY and bpy.app.version >= (3,2)) 
 993
 994        #if not is_fast_create:
 995        #    bpy.ops.object.mode_set(mode='VERTEX_PAINT')
 996        #    prev_brush_color = context.tool_settings.vertex_paint.brush.color
 997        
 998        vert_loops = dict()
 999        for loop_index, loop in enumerate(me.loops):
1000            vert_loops.setdefault(loop.vertex_index, list()).append(loop_index)
1001        
1002        def fill_color_layer(layer, color):
1003            import numpy as np
1004            color_np = np.array(color, dtype=float)
1005            color_values = np.broadcast_to(color_np, (len(me.loops), len(color_np)))
1006            layer.data.foreach_set('color', color_values.ravel())
1007
1008        def create_normals_color(name):
1009            default_color = (0.5, 0.5, 0.5, 1.0)
1010
1011            #if is_fast_create:
1012            #    bpy.ops.geometry.color_attribute_add(name=name, domain='CORNER', data_type='FLOAT_COLOR', color=default_color)
1013            #    return me.attributes.active
1014            
1015            if is_use_attributes:
1016                normals_color = me.attributes.new(name, 'FLOAT_COLOR', 'CORNER')
1017            else:
1018                normals_color = me.vertex_colors.new(name=name, do_init=False) or me.vertex_colors[-1]
1019
1020            fill_color_layer(normals_color, default_color)
1021            
1022            return normals_color
1023        
1024        def create_unknown_color(data):
1025            unknown_color = None
1026            if len(data['data']) and data['data'][0]['color']:
1027                if is_use_attributes:
1028                    unknown_color = me.attributes.new(f"{data['name']}_unknown", 'FLOAT_COLOR', 'CORNER')
1029                else:
1030                    unknown_color = me.vertex_colors.new(name=f"{data['name']}_unknown", do_init=False) or me.vertex_colors[-1]
1031            return unknown_color
1032
1033        def set_shape_key_data(shape_key, normals_color, unknown_color):
1034            for vert in data['data']:
1035                vert_index = vert['index']
1036                co = compat.convert_cm_to_bl_space( mathutils.Vector(vert['co']) * self.scale )
1037                no = compat.convert_cm_to_bl_space( mathutils.Vector(vert['normal']))
1038                shape_key.data[vert_index].co = shape_key.data[vert_index].co + co
1039
1040                write_vertex_colors(vert, no, normals_color, unknown_color)
1041
1042        def write_vertex_colors(vert, no, normals_color, unknown_color):
1043            for loop_index in vert_loops[vert['index']]:
1044                normals_color.data[loop_index].color = ( # convert from range(-1, 1) to range(0, 1)
1045                    no[0] * 0.5 + 0.5,
1046                    no[1] * 0.5 + 0.5,
1047                    no[2] * 0.5 + 0.5,
1048                    1,
1049                )
1050                if not vert['color']:
1051                    continue
1052                unknown_color.data[loop_index].color = ( # convert from range(-1, 1) to range(0, 1)
1053                    vert['color'][0] * 0.5 * vert['color'][3] + 0.5,
1054                    vert['color'][1] * 0.5 * vert['color'][3] + 0.5,
1055                    vert['color'][2] * 0.5 * vert['color'][3] + 0.5,
1056                    1,
1057                )
1058
1059        morph_count = -1
1060        for data in misc_data:
1061            if not data['type'] == 'morph':
1062                continue
1063            
1064            morph_count += 1
1065
1066            if morph_count == 0:
1067                bpy.ops.object.shape_key_add(from_mix=False)
1068                me.shape_keys.name = ob.name
1069            shape_key = ob.shape_key_add(name=data['name'], from_mix=False)
1070            
1071            normals_color = create_normals_color(f"{data['name']}_delta_normals")
1072            unknown_color = create_unknown_color(data)
1073            set_shape_key_data(shape_key, normals_color, unknown_color)
1074
1075
1076    def create_mateprop_old(self, context, me, tex_set, mate, mate_idx, data: list):
1077        # create_matepropとの違いは、slot_indexの有無、nodeの接続・配置処理のみ
1078
1079        prefs = common.preferences()
1080        # テクスチャ追加
1081        slot_index = 0
1082        for tex_data in data['data']:
1083            if prefs.mate_unread_same_value:
1084                if tex_data['name'] in tex_set:
1085                    continue
1086                tex_set.add(tex_data['name'])
1087
1088            node_name = tex_data['name']
1089            if tex_data['type'] == 'tex':
1090                path = tex_data['path']
1091                tex_map_data = tex_data['tex_map']
1092                common.create_tex(context, mate, node_name, tex_data['name2'], path, path, tex_map_data, prefs.is_replace_cm3d2_tex, slot_index)
1093
1094            elif tex_data['type'] == 'col':
1095                col = tex_data['color']
1096                common.create_col(context, mate, node_name, col, slot_index)
1097
1098            elif tex_data['type'] == 'f':
1099                f = tex_data['float']
1100                common.create_f(context, mate, node_name, f, slot_index)
1101
1102            slot_index += 1
1103
1104            self.progress(context)
1105
1106    def create_mateprop(self, context, me, tex_set, mate, mate_idx, data: list):
1107        if mate.use_nodes is False:
1108            mate.use_nodes = True
1109
1110        nodes = mate.node_tree.nodes
1111        prefs = common.preferences()
1112
1113        for prop_data in data['data']:
1114            if prefs.mate_unread_same_value:
1115                if prop_data['name'] in tex_set:
1116                    continue
1117                tex_set.add(prop_data['name'])
1118
1119            if prop_data['type'] == 'tex':  # テクスチャ追加
1120                prop_name = prop_data['name']
1121                if prop_data['type2'] == 'tex2d':
1122                    tex_name = prop_data['name2']
1123                    cm3d2path = prop_data['path']
1124                    tex_map = prop_data['tex_map']
1125                    tex = common.create_tex(context, mate, prop_name, tex_name, cm3d2path, cm3d2path, tex_map)
1126
1127                    if prop_data['type2'] == 'tex2d':
1128                        mapping = prop_data['tex_map']
1129                        tex_map = tex.texture_mapping
1130                        tex_map.translation[0] = mapping[0]
1131                        tex_map.translation[1] = mapping[1]
1132                        tex_map.scale[0] = mapping[2]
1133                        tex_map.scale[1] = mapping[3]
1134
1135                        # ファイルの実体を割り当て
1136                        if prefs.is_replace_cm3d2_tex:
1137                            img = tex.image
1138                            # col = mate.node_tree.nodes.new(type='ShaderNodeAttribute')
1139                            # tex.image = bpy.data.images.load("C:\\path\\to\\im.jpg")
1140                            replaced = common.replace_cm3d2_tex(img, self.texpath_dict, reload_path=False)
1141                            if compat.IS_LEGACY and replaced and prop_name == '_MainTex':
1142                                for face in me.polygons:
1143                                    if face.material_index == mate_idx:
1144                                        me.uv_textures.active.data[face.index].image = img
1145                else:
1146                    common.create_tex(context, mate, prop_name)
1147
1148            elif prop_data['type'] == 'col':
1149                col = nodes.new(type='ShaderNodeRGB')
1150                col.name = col.label = prop_data['name']
1151                # val.type = 'RGB'
1152                col.outputs[0].default_value = prop_data['color'][:4]
1153
1154                # mate.node_tree.links.new(bsdf.inputs['xxx'], val.outputs['Color'])
1155                # mate.node_tree.nodes.active = col
1156
1157                # slot = mate.texture_slots.create(tex_index)
1158                # mate.use_textures[tex_index] = False
1159                # slot.diffuse_color_factor = tex_data['color'][3]
1160                # slot.use_rgb_to_intensity = True
1161                # tex = context.blend_data.textures.new(tex_data['name'], 'BLEND')
1162                # slot.texture = tex
1163
1164            elif prop_data['type'] == 'f':
1165                val = nodes.new(type='ShaderNodeValue')
1166                val.name = prop_data['name']
1167                val.label = prop_data['name']
1168                # val.type = 'VALUE'
1169                # mate.node_tree.links.new(bsdf.inputs['xxx'], val.outputs['Value'])
1170
1171                val.outputs[0].default_value = prop_data['float']
1172
1173            self.progress(context)
1174
1175        cm3d2_data.align_nodes(mate)
1176
1177    def progress(self, context):
1178        self.progress_count += self.progress_plus_value
1179        context.window_manager.progress_update(self.progress_count)
1180
1181
1182# メニューを登録する関数
1183def menu_func(self, context):
1184    self.layout.operator(CNV_OT_import_cm3d2_model.bl_idname, icon_value=common.kiss_icon())